#include "DeviceManagementWidget.h"
#include "ui_DeviceManagementWidget.h"
#include <QDebug>
#include <QStringList>
#include <QSignalBlocker>

//比较特殊的两个按钮所以单独出来管理
//实时采集按钮名称
#define CONTINUOUSACQUISTIONBUTTON "continuousAcquisitionButton"
//内触发按钮名称
#define INTERNALTRIGGERBUTTON "internalTriggerButton"

/**
 * @brief 构造函数实现
 * 
 * 初始化设备管理界面，连接各种信号和槽，设置初始状态。
 * 发现并显示已连接的相机和控制模块，初始化UI状态。
 */
DeviceManagementWidget::DeviceManagementWidget(SDKManager *sdkManager, QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::DeviceManagementWidget)
    , m_cameraConnected(false)
    , m_controlModuleConnected(false)
    , m_cameraParametersWidget(nullptr)
    , m_controlModuleParametersWidget(nullptr)
    , m_cameraParametersDialog(nullptr)
    , m_controlModuleParametersDialog(nullptr)
{
    ui->setupUi(this);
    
    // 初始化SDK管理器
    m_SDKManager = sdkManager;
    
    // 连接相机管理相关信号
    connect(m_SDKManager, &SDKManager::cameraConnected, this, &DeviceManagementWidget::onCameraConnected);
    connect(m_SDKManager, &SDKManager::cameraDisconnected, this, &DeviceManagementWidget::onCameraDisconnected);
    

    // 连接控制模块管理相关信号
    connect(m_SDKManager, &SDKManager::controlModuleConnected, this, &DeviceManagementWidget::onControlModuleConnected);
    connect(m_SDKManager, &SDKManager::controlModuleDisconnected, this, &DeviceManagementWidget::onControlModuleDisconnected);
    

    // 仅保留必要的连接控制信号
    connect(ui->connectCameraButton, &QPushButton::clicked, this, &DeviceManagementWidget::onConnectCameraButtonClicked);
    connect(ui->connectControlModuleButton, &QPushButton::clicked, this, &DeviceManagementWidget::onConnectControlModuleButtonClicked);
    connect(ui->controlModuleSettingsButton, &QPushButton::clicked, this, &DeviceManagementWidget::onSKSetButtonClicked);
    connect(ui->cameraSettingsButton, &QPushButton::clicked, this, &DeviceManagementWidget::onCameraSetButtonClicked);

    // 连接触发按钮信号
    connect(ui->singleExternalTriggerButton, &QPushButton::clicked, this, [=]() {
        onTriggerModeChanged(TRIGGER_MODE_EXTERNAL_SINGLE);
    });
    connect(ui->continuousExternalTriggerButton, &QPushButton::clicked, this, [=]() {
        onTriggerModeChanged(TRIGGER_MODE_EXTERNAL_CONTINUOUS);
    });
    connect(ui->internalTriggerButton, &QPushButton::clicked, this, [=]() {
        onTriggerModeChanged(TRIGGER_MODE_INTERNAL);
    });
    connect(ui->continuousAcquisitionButton, &QPushButton::clicked, this, [=]() {
        onTriggerModeChanged(TRIGGER_MODE_CONTINUOUS);
    });

    // 参数设置控件已从UI文件中移除，现在通过外部UI组件提供参数设置功能
    
    // 初始化UI状态
    updateConnectionUI();
    updateTriggerButtonsState();

    {
        QList<QPushButton*> lists = ui->controllerGroupWidget->findChildren<QPushButton*>();
        for(int i =0 ; i < lists.size() ;i ++){
            QPushButton* btn = lists.at(i);
            connect(btn,&QPushButton::clicked,this,[this, btn](bool){
                updateControllerBtn(btn);
            });
        }
    }
}

/**
 * @brief 析构函数实现
 * 
 * 释放UI资源，注意不需要显式删除设备管理器指针，因为它们由插件管理。
 */
DeviceManagementWidget::~DeviceManagementWidget()
{
    // 在析构函数中，不需要显式删除m_cameraManager和m_controlModuleManager，
    // 因为它们由DeviceManagementPlugin创建和管理
    delete ui;
}

void DeviceManagementWidget::getImageComplete()
{
    switch (m_triggerMode) {
    case TRIGGER_MODE_CONTINUOUS:{}break;
    case TRIGGER_MODE_EXTERNAL_SINGLE:{
        ui->singleExternalTriggerButton->setChecked(false);
        ui->continuousAcquisitionButton->click();
    }break;
    case TRIGGER_MODE_EXTERNAL_CONTINUOUS:{}break;
    case TRIGGER_MODE_INTERNAL:{
        ui->internalTriggerButton->setChecked(false);
        ui->continuousAcquisitionButton->click();
    }break;
    }
}

/**
 * @brief 更新连接状态UI的实现
 * 
 * 根据相机和控制模块的连接状态，更新UI元素的显示，包括：
 * - 连接状态图标
 * - 连接按钮文本
 * - 各种参数调整控件的启用状态
 */
void DeviceManagementWidget::updateConnectionUI()
{
    // 更新相机连接UI
    if (m_cameraConnected) {
        ui->cameraConnectionStatusIcon->setProperty("connected", true);
        ui->cameraConnectionStatusIcon->style()->unpolish(ui->cameraConnectionStatusIcon);
        ui->cameraConnectionStatusIcon->style()->polish(ui->cameraConnectionStatusIcon);
        ui->connectCameraButton->setText("断开相机");
        ui->cameraSelector->setEnabled(false);
        
        // 更新外部UI组件的启用状态
        if (m_cameraParametersWidget) {
            m_cameraParametersWidget->setEnabled(true);
        }
        
        // 根据相机连接状态和对话框是否设置，启用或禁用相机设置按钮
        ui->cameraSettingsButton->setEnabled(m_cameraParametersDialog != nullptr);
    } else {
        ui->cameraConnectionStatusIcon->setProperty("connected", false);
        ui->cameraConnectionStatusIcon->style()->unpolish(ui->cameraConnectionStatusIcon);
        ui->cameraConnectionStatusIcon->style()->polish(ui->cameraConnectionStatusIcon);
        ui->connectCameraButton->setText("连接相机");
        ui->cameraSelector->setEnabled(true);
        
        // 更新外部UI组件的启用状态
        if (m_cameraParametersWidget) {
            m_cameraParametersWidget->setEnabled(false);
        }
        
        // 相机未连接时，禁用相机设置按钮
        ui->cameraSettingsButton->setEnabled(false);
    }

    // 更新控制模块连接UI
    if (m_controlModuleConnected) {
        ui->moduleConnectionStatusIcon->setProperty("connected", true);
        ui->moduleConnectionStatusIcon->style()->unpolish(ui->moduleConnectionStatusIcon);
        ui->moduleConnectionStatusIcon->style()->polish(ui->moduleConnectionStatusIcon);
        ui->connectControlModuleButton->setText("断开模块");
        ui->controlModuleSelector->setEnabled(false);
        
        // 更新外部UI组件的启用状态
        if (m_controlModuleParametersWidget) {
            m_controlModuleParametersWidget->setEnabled(true);
        }
        
        // 根据控制模块连接状态和对话框是否设置，启用或禁用SK设置按钮
        ui->controlModuleSettingsButton->setEnabled(m_controlModuleParametersDialog != nullptr);
    } else {
        ui->moduleConnectionStatusIcon->setProperty("connected", false);
        ui->moduleConnectionStatusIcon->style()->unpolish(ui->moduleConnectionStatusIcon);
        ui->moduleConnectionStatusIcon->style()->polish(ui->moduleConnectionStatusIcon);
        ui->connectControlModuleButton->setText("连接模块");
        ui->controlModuleSelector->setEnabled(true);
        
        // 更新外部UI组件的启用状态    m_controlModuleParametersWidget  = 0x0
//        if (m_controlModuleParametersWidget) {
//            m_controlModuleParametersWidget->setEnabled(false);
//        }
        
        // 控制模块未连接时，禁用SK设置按钮
        ui->controlModuleSettingsButton->setEnabled(false);
    }
}

/**
 * @brief 更新触发按钮状态的实现
 * 
 * 根据相机和控制模块的连接状态，启用或禁用所有触发控制按钮。
 * 只有当相机和控制模块都已连接时，才允许触发操作。
 */
void DeviceManagementWidget::updateTriggerButtonsState()
{
    bool canTrigger = m_cameraConnected && m_controlModuleConnected;
    QList<QPushButton*> lists = ui->controllerGroupWidget->findChildren<QPushButton*>();
    for(int i =0 ; i < lists.size() ;i ++){
        QPushButton* btn = lists.at(i);
        if(btn->objectName() == CONTINUOUSACQUISTIONBUTTON){
            btn->setEnabled(m_cameraConnected);
        }else{
            btn->setEnabled(canTrigger);
        }
    }
}

void DeviceManagementWidget::updateControllerBtn(QPushButton  *button)
{
    if(m_LastClickedBtn!=nullptr){
        if(m_LastClickedBtn == button){
        }else{
            m_LastClickedBtn->setChecked(false);
            qDebug() << __LINE__ << "m_LastClickedBtn:" << m_LastClickedBtn->objectName();
        }
    }
    m_LastClickedBtn = button;
}

/**
 * @brief 相机连接按钮点击事件处理的实现
 * 
 * 根据当前相机连接状态，执行连接或断开操作：
 * - 如果已连接，则调用相机管理器的disconnectDevice方法断开连接
 * - 如果未连接，则获取选中的相机并尝试连接
 */
void DeviceManagementWidget::onConnectCameraButtonClicked()
{
    QString selectedCamera = ui->cameraSelector->currentText();
    if (selectedCamera.isEmpty())
    {
        return;
    }
    if (m_cameraConnected) {
        m_SDKManager->disconnectDevice(selectedCamera);
        ui->singleExternalTriggerButton->setChecked(false);
        ui->continuousExternalTriggerButton->setChecked(false);
        ui->internalTriggerButton->setChecked(false);
        ui->continuousAcquisitionButton->setChecked(false);
    }
    else
    {
        m_ConnectCameraId=selectedCamera;
        if (m_SDKManager->connectDevice(selectedCamera))
        {
           ui->continuousAcquisitionButton->setChecked(true);
           m_LastClickedBtn = ui->continuousAcquisitionButton;
        }else{
            m_ConnectCameraId = "";
        }
    }
}

/**
 * @brief 相机连接成功槽函数的实现
 * 
 * 当相机成功连接时被调用，更新连接状态标志并刷新UI。
 */
void DeviceManagementWidget::onCameraConnected()
{
    m_cameraConnected = true;
    
    // 如果相机ID不为空，尝试获取相机参数对话框和快捷参数设置widget
    if (!m_ConnectCameraId.isEmpty()) {
        // 获取并设置相机参数对话框
        QDialog* cameraDialog = m_SDKManager->getDeviceParameterDialog(m_ConnectCameraId,this);
        if (cameraDialog) {
            setExternalCameraParametersDialog(cameraDialog);
        }
        
        // 获取并设置相机快捷参数设置widget
        QWidget* cameraWidget = m_SDKManager->getDeviceQuickParameterWidget(m_ConnectCameraId);
        if (cameraWidget) {
            setCameraParametersWidget(cameraWidget);
        }
    }
    
    updateConnectionUI();
    updateTriggerButtonsState();
}

/**
 * @brief 相机断开连接槽函数的实现
 * 
 * 当相机断开连接时被调用，更新连接状态标志并刷新UI。
 */
void DeviceManagementWidget::onCameraDisconnected()
{
    m_cameraConnected = false;
    updateConnectionUI();
    updateTriggerButtonsState();
}

/**
 * @brief 曝光值变化事件处理的实现
 * 
 * 当曝光滑块值变化时被调用，更新显示标签并发出相应信号。
 */
// 注：所有参数设置相关的槽函数已移除
// 参数设置功能现在通过外部UI组件提供

/**
 * @brief 触发模式变化事件处理的实现
 * 
 * 当触发模式变化时被调用，根据不同的触发模式执行相应的设置。
 * 目前只有调试输出，具体实现逻辑尚未完成。
 */
void DeviceManagementWidget::onTriggerModeChanged(int mode)
{
    if(m_triggerMode==mode)
    {
        return;
    }

    // 更新内部状态
    m_triggerMode = mode;

    // 相机触发模式设置
    if (m_cameraConnected && !m_ConnectCameraId.isEmpty())
    {
         m_SDKManager->setDeviceTriggerMode(m_ConnectCameraId, mode);
    }
    
    // 控制模块触发模式设置
    if (m_controlModuleConnected && !m_ConnectControlModuleId.isEmpty())
    {
        m_SDKManager->setDeviceTriggerMode(m_ConnectControlModuleId, mode);
    }
}


/**
 * @brief 设置外部相机参数对话框的实现
 * 
 * 设置用于相机参数调整的外部对话框，供按钮点击时显示。
 */
void DeviceManagementWidget::setExternalCameraParametersDialog(QWidget *dialog)
{
    if(m_cameraParametersDialog)
    {
        m_cameraParametersDialog->setParent(nullptr);
        m_cameraParametersDialog->hide();
    }
    m_cameraParametersDialog = dialog;
    
    // 根据相机连接状态和对话框是否设置，更新相机设置按钮状态
    ui->cameraSettingsButton->setEnabled(m_cameraConnected && (m_cameraParametersDialog != nullptr));
}

/**
 * @brief 设置外部控制模块参数对话框的实现
 * 
 * 设置用于控制模块参数调整的外部对话框，供按钮点击时显示。
 */
void DeviceManagementWidget::setExternalControlModuleParametersDialog(QWidget *dialog)
{
//    if(m_controlModuleParametersDialog)
//    {
//        m_controlModuleParametersDialog->setParent(nullptr);
//        m_controlModuleParametersDialog->hide();
//    }
    m_controlModuleParametersDialog = dialog;
    
    // 根据控制模块连接状态和对话框是否设置，更新SK设置按钮状态
    ui->controlModuleSettingsButton->setEnabled(m_controlModuleConnected && (m_controlModuleParametersDialog != nullptr));
}

/**
 * @brief SK设置按钮点击事件处理的实现
 *
 * 显示外部注册的SK功能设置对话框。
 * 注意：不再提供备用方案，必须通过setExternalControlModuleParametersDialog方法注册对话框。
 */
void DeviceManagementWidget::onSKSetButtonClicked()
{
    // 显示外部注册的控制模块参数对话框（SK设置对话框）
    if (m_controlModuleParametersDialog) {
//        m_controlModuleParametersDialog->setParent(this);
        m_controlModuleParametersDialog->show();
    } else {
        qDebug() << "No external control module parameters dialog registered";
    }
}

/**
 * @brief 相机设置按钮点击事件处理的实现
 * 
 * 显示外部注册的相机参数对话框。
 * 注意：不再提供备用方案，必须通过setExternalCameraParametersDialog方法注册对话框。
 */
void DeviceManagementWidget::onCameraSetButtonClicked()
{
    // 显示外部注册的相机参数对话框
    if (m_cameraParametersDialog) {
//        m_cameraParametersDialog->setParent(this);
        m_cameraParametersDialog->show();
    } else {
        qDebug() << "No external camera parameters dialog registered";
    }
}

/**
 * @brief 控制模块连接按钮点击事件处理的实现
 * 
 * 根据当前控制模块连接状态，执行连接或断开操作：
 * - 如果已连接，则调用SDK管理器的disconnectDevice方法断开连接
 * - 如果未连接，则获取选中的控制模块并尝试连接
 */
/**
 * @brief 控制模块连接成功槽函数的实现
 * 
 * 当控制模块成功连接时被调用，更新连接状态标志并刷新UI。
 */
void DeviceManagementWidget::onControlModuleConnected()
{
    m_controlModuleConnected = true;
    
    // 如果控制模块ID不为空，尝试获取控制模块参数对话框和快捷参数设置widget
    if (!m_ConnectControlModuleId.isEmpty()) {
        // 获取并设置控制模块参数对话框
        QDialog* moduleDialog = m_SDKManager->getDeviceParameterDialog(m_ConnectControlModuleId,this);
        if (moduleDialog) {
            setExternalControlModuleParametersDialog(moduleDialog);
        }
        
        // 获取并设置控制模块快捷参数设置widget
        QWidget* moduleWidget = m_SDKManager->getDeviceQuickParameterWidget(m_ConnectControlModuleId);
        if (moduleWidget) {
            setControlModuleParametersWidget(moduleWidget);
        }
    }
    
    updateConnectionUI();
    updateTriggerButtonsState();
}

/**
 * @brief 控制模块断开连接槽函数的实现
 * 
 * 当控制模块断开连接时被调用，更新连接状态标志并刷新UI。
 */
void DeviceManagementWidget::onControlModuleDisconnected()
{
    m_controlModuleConnected = false;
    updateConnectionUI();
    updateTriggerButtonsState();
}

/**
 * @brief 控制模块连接按钮点击事件处理的实现
 */
void DeviceManagementWidget::onConnectControlModuleButtonClicked()
{
    QString selectedModule = ui->controlModuleSelector->currentText();
    if (selectedModule.isEmpty())
    {
        return;
    }
    if (m_controlModuleConnected) {
        m_SDKManager->disconnectDevice(selectedModule);
        ui->singleExternalTriggerButton->setChecked(false);
        ui->continuousExternalTriggerButton->setChecked(false);
        ui->internalTriggerButton->setChecked(false);
    }
    else
    {
        m_ConnectControlModuleId = selectedModule;
        if (m_SDKManager->connectDevice(selectedModule))
        {
            ui->singleExternalTriggerButton->setEnabled(true);
            ui->continuousExternalTriggerButton->setEnabled(true);
            ui->internalTriggerButton->setEnabled(true);
        }else{
            m_ConnectControlModuleId = "";
        }
    }
}

/**
 * @brief 刷新设备按钮点击自动槽的实现
 * 
 * 通过 Qt 自动连接机制触发，执行设备重新发现与列表更新。
 * 步骤：
 * - 保存当前选择
 * - 清空并重新填充相机与控制模块列表
 * - 尝试恢复之前选择
 * - 更新连接状态和触发按钮可用性
 */
void DeviceManagementWidget::on_refreshDevicesButton_clicked()
{
    // 保存当前选中的相机和控制模块名称
    QString currentCamera = ui->cameraSelector->currentText();
    QString currentModule = ui->controlModuleSelector->currentText();

    // 清除现有的相机列表并重新发现相机设备
    ui->cameraSelector->clear();

    // 获取所有发现的相机设备列表并添加到下拉列表
    QList<QVariant> cameras =  m_SDKManager->discoverCameraDevices();
    for (const QVariant &camera : qAsConst(cameras))
    {
        ui->cameraSelector->addItem(camera.toString());
    }

    // 如果之前有选中的相机，尝试重新选中它
    if (!currentCamera.isEmpty())
    {
        int camIndex = ui->cameraSelector->findText(currentCamera);
        if (camIndex != -1)
        {
            ui->cameraSelector->setCurrentIndex(camIndex);
        }
    }
    else if (ui->cameraSelector->count() > 0)
    {
        // 如果没有之前的选择且列表非空，默认选中第一项
        ui->cameraSelector->setCurrentIndex(0);
    }

    // 清除现有的控制模块列表并重新发现控制模块设备
    ui->controlModuleSelector->clear();

    // 获取所有发现的控制模块设备列表并添加到下拉列表
    QList<QVariant> modules = m_SDKManager->discoverControlModuleDevices();
    for (const QVariant &module : qAsConst(modules))
    {
        if(module.type() == QVariant::String){
            ui->controlModuleSelector->addItem(module.toString());
        }
    }

    // 如果之前有选中的控制模块，尝试重新选中它
    if (!currentModule.isEmpty()) {
        int modIndex = ui->controlModuleSelector->findText(currentModule);
        if (modIndex != -1) {
            ui->controlModuleSelector->setCurrentIndex(modIndex);
        }
    } else if (ui->controlModuleSelector->count() > 0) {
        // 如果没有之前的选择且列表非空，默认选中第一项
        ui->controlModuleSelector->setCurrentIndex(0);
    }

    // 刷新UI状态
    updateConnectionUI();
    updateTriggerButtonsState();
}

void DeviceManagementWidget::setCameraParametersWidget(QWidget *widget)
{
    // 如果已有相机参数UI组件，先移除它
    if (m_cameraParametersWidget)
    {
        ui->verticalLayout_Content->removeWidget(m_cameraParametersWidget);
        // 断开连接并移除旧的UI组件
//        m_cameraParametersWidget->setParent(nullptr);成了野人，无法被操作。
        // 注意：此处不删除组件，因为它可能由外部管理生命周期
//        m_cameraParametersWidget->deleteLater();
        m_cameraParametersWidget = nullptr;
    }
    
    // 设置新的相机参数UI组件（快捷操作控件）
    if (widget) {
        m_cameraParametersWidget = widget;
        m_cameraParametersWidget->setParent(this);
        m_cameraParametersWidget->setEnabled(m_cameraConnected);
        ui->verticalLayout_Content->insertWidget(2,widget);
        m_cameraParametersWidget->show();
    }
}

void DeviceManagementWidget::setControlModuleParametersWidget(QWidget *widget)
{
    // 如果已有控制模块参数UI组件，先移除它
    if (m_controlModuleParametersWidget)
    {
        ui->verticalLayout_Content->removeWidget(m_controlModuleParametersWidget);
        // 断开连接并移除旧的UI组件
        //m_controlModuleParametersWidget 成了野人，无法被操作。
//        m_controlModuleParametersWidget->setParent(nullptr);
        // 注意：此处不删除组件，因为它可能由外部管理生命周期
//        m_controlModuleParametersWidget->deleteLater();
        m_controlModuleParametersWidget = nullptr;
    }
    
    // 设置新的控制模块参数UI组件（快捷操作控件）
    if (widget)
    {
        m_controlModuleParametersWidget = widget;
        m_controlModuleParametersWidget->setParent(this);
        m_controlModuleParametersWidget->setEnabled(m_controlModuleConnected);
        ui->verticalLayout_Content->insertWidget(3,widget);
        m_controlModuleParametersWidget->show();
    }
}

